!pip install opencv-contrib-python

Requirement already satisfied: opencv-contrib-python in c:\users\aleja\anaconda3\lib\site-packages (4.5.1.48)
Requirement already satisfied: numpy>=1.17.3 in c:\users\aleja\anaconda3\lib\site-packages (from opencv-contrib-python) (1.19.2)

import cv2
import matplotlib.pyplot as plt
import numpy as np
import math
from skimage import io, color

#Construimos una funcion que nos facilita la lectura de las imagenes

def img_read(filename, mode = 'color'):
    if(mode == 'color'):   
        return cv2.cvtColor(cv2.imread(filename),cv2.COLOR_BGR2RGB)
    elif(mode=='grayscale' or mode=='greyscale' or mode == 'gray' or mode == 'grey'):
        return cv2.imread(filename, cv2.IMREAD_GRAYSCALE)
    elif(mode=='yuv' or mode=='YUV'):
        return cv2.cvtColor(cv2.imread(filename),cv2.COLOR_BGR2YUV)
    elif(mode=='hsv' or mode=='HSV'):
        return cv2.cvtColor(cv2.imread(filename),cv2.COLOR_BGR2HSV)
    elif(mode=='lab' or mode=='LAB'):
        return cv2.cvtColor(cv2.imread(filename),cv2.COLOR_BGR2LAB)
    else:
        return None

img_rgb = img_read('images/training/images/35_training.tif')

#Modelo RGB
img_R = img_rgb[:,:,0]
img_G = img_rgb[:,:,1]
img_B = img_rgb[:,:,2]

fig, (ax1, ax2, ax3) = plt.subplots(1,3, figsize=(15, 6))

fig.suptitle('Canales RGB', fontsize=15)
ax1.set_title('Canal R')
ax1.imshow(img_R, cmap='gray')
ax2.set_title('Canal G')
ax2.imshow(img_G, cmap='gray')
ax3.set_title('Canal B')
ax3.imshow(img_B, cmap='gray')

<matplotlib.image.AxesImage at 0x195aed4a610>

img_cmy = img_read('images/training/images/35_training.tif')

#Modelo CMY
img_C= 255 - img_cmy[:,:,0]
img_M = 255 - img_cmy[:,:,1]
img_Y = 255 - img_cmy[:,:,2]

fig, (ax1, ax2, ax3) = plt.subplots(1,3, figsize=(15, 6))

fig.suptitle('Canales CMY', fontsize=15)
ax1.set_title('Canal C')
ax1.imshow(img_C, cmap='gray')
ax2.set_title('Canal M')
ax2.imshow(img_M, cmap='gray')
ax3.set_title('Canal Y')
ax3.imshow(img_Y, cmap='gray')

<matplotlib.image.AxesImage at 0x195aee611f0>

img_yiq = img_read('images/training/images/35_training.tif')

#Modelo YIQ
img_R = img_yiq[:,:,0]
img_G = img_yiq[:,:,1]
img_B = img_yiq[:,:,2]

img_Y = 0.299*img_R + 0.587*img_G + 0.114*img_B
img_I = 0.596*img_R - 0.274*img_G - 0.322*img_B
img_Q = 0.211*img_R - 0.523*img_G + 0.312*img_B

fig, (ax1, ax2, ax3) = plt.subplots(1,3, figsize=(15, 6))

fig.suptitle('Canales YIQ', fontsize=15)
ax1.set_title('Canal Y')
ax1.imshow(img_Y, cmap='gray')
ax2.set_title('Canal I')
ax2.imshow(img_I, cmap='gray')
ax3.set_title('Canal Q')
ax3.imshow(img_Q, cmap='gray')

<matplotlib.image.AxesImage at 0x195aef613d0>

img_yuv = img_read('images/training/images/35_training.tif',mode="yuv")

#Modelo YUV

img_Y = img_yuv[:,:,0]
img_U =  img_yuv[:,:,1]
img_V = img_yuv[:,:,2]

fig, (ax1, ax2, ax3) = plt.subplots(1,3, figsize=(15, 6))

fig.suptitle('Canales YUV', fontsize=15)
ax1.set_title('Canal Y')
ax1.imshow(img_Y, cmap='gray')
ax2.set_title('Canal U')
ax2.imshow(img_U, cmap='gray')
ax3.set_title('Canal V')
ax3.imshow(img_V, cmap='gray')

<matplotlib.image.AxesImage at 0x195b0589040>

img_HSL = img_read('images/training/images/35_training.tif')

#Modelo HSL

img_rgb = img_HSL.astype(np.float32)/255
img_R = img_rgb[:,:,0]
img_G = img_rgb[:,:,1]
img_B = img_rgb[:,:,2]

tam = np.shape(img_rgb)
img_hsl =np.zeros((tam), dtype=np.float32)

for i in range(tam[0]):
    for j in range(tam[1]):
        max_val = np.max(img_rgb[i][j])
        min_val = np.min(img_rgb[i][j])
        s = max_val - min_val
        l = s/2
        img_hsl[i][j][1] = s
        img_hsl[i][j][2] = l
        if(max_val==min_val):
            img_hsl[i][j][0] = 0
            continue
        red = img_rgb[i][j][0]
        green = img_rgb[i][j][1]
        blue = img_rgb[i][j][2]
        if(max_val == red):
            h = (green-blue)*60/(max_val-min_val)
        elif(max_val == green):
            h = (blue-red)*60/(max_val-min_val) + 120
        else:
            h = (red-green)*60/(max_val-min_val) + 240
        if h >= 0:
            img_hsl[i,j,0]=h
        else:
            img_hsl[i,j,0] = 360.0 - h

fig, (ax1, ax2, ax3) = plt.subplots(1,3, figsize=(15, 6))

fig.suptitle('Canales HSL', fontsize=15)
ax1.set_title('Canal H')
ax1.imshow(img_hsl[:,:,0], cmap='gray')
ax2.set_title('Canal S')
ax2.imshow(img_hsl[:,:,1], cmap='gray')
ax3.set_title('Canal L')
ax3.imshow(img_hsl[:,:,2], cmap='gray')

<matplotlib.image.AxesImage at 0x195b126c5b0>

img_hsv = img_read('images/training/images/35_training.tif',mode="hsv")

#Modelo HSV

img_H = img_hsv[:,:,0]
img_S =  img_hsv[:,:,1]
img_V = img_hsv[:,:,2]

fig, (ax1, ax2, ax3) = plt.subplots(1,3, figsize=(15, 6))

fig.suptitle('Canales HSV', fontsize=15)
ax1.set_title('Canal H')
ax1.imshow(img_H, cmap='gray')
ax2.set_title('Canal S')
ax2.imshow(img_S, cmap='gray')
ax3.set_title('Canal V')
ax3.imshow(img_V, cmap='gray')

<matplotlib.image.AxesImage at 0x195b1ffb370>

img_lab = img_read('images/training/images/35_training.tif',mode="lab")

#Modelo LAB

img_L = img_lab[:,:,0]
img_A =  img_lab[:,:,1]
img_B = img_lab[:,:,2]

fig, (ax1, ax2, ax3) = plt.subplots(1,3, figsize=(15, 6))
fig.suptitle('Canales LAB', fontsize=15)
ax1.set_title('Canal L')
ax1.imshow(img_L, cmap='gray')
ax2.set_title('Canal A')
ax2.imshow(img_A, cmap='gray')
ax3.set_title('Canal B')
ax3.imshow(img_B, cmap='gray')

<matplotlib.image.AxesImage at 0x195b20ea550>

Comparativa entre canales:

Procederemos a hacer una comparacion entre estos tres canales seleccionados con cinco distintas imagenes del dataset que creemos tienen unas caracteristicas distintivas, como una mayor iluminacion o un color de la retina un tanto distinto. Para asi hallar el canal mas apropiado para todo tipo de situación.

#Leamos estas imagenes representativas para compararlas

imagen1 = img_read('images/training/images/34_training.tif')
imagen2 = img_read('images/training/images/31_training.tif')
imagen3 = img_read('images/training/images/38_training.tif')
imagen4 = img_read('images/training/images/23_training.tif')
imagen5 = img_read('images/training/images/26_training.tif')

imagen1yuv = img_read('images/training/images/34_training.tif',mode="yuv")
imagen2yuv = img_read('images/training/images/31_training.tif',mode="yuv")
imagen3yuv = img_read('images/training/images/38_training.tif',mode="yuv")
imagen4yuv = img_read('images/training/images/23_training.tif',mode="yuv")
imagen5yuv = img_read('images/training/images/26_training.tif',mode="yuv")

fig, (ax1, ax2, ax3, ax4, ax5) = plt.subplots(1,5, figsize=(15, 6))
fig.suptitle('Canal G - RGB', fontsize=15)
ax1.set_title('Canal G - Imagen 1')
ax1.imshow(imagen1[:,:,1], cmap='gray')
ax2.set_title('Canal G - Imagen 2')
ax2.imshow(imagen2[:,:,1], cmap='gray')
ax3.set_title('Canal G - Imagen 3')
ax3.imshow(imagen3[:,:,1], cmap='gray')
ax4.set_title('Canal G - Imagen 4')
ax4.imshow(imagen4[:,:,1], cmap='gray')
ax5.set_title('Canal G - Imagen 5')
ax5.imshow(imagen5[:,:,1], cmap='gray')

fig, (ax1, ax2, ax3, ax4, ax5) = plt.subplots(1,5, figsize=(15, 6))
fig.suptitle('Canal Y - YUV', fontsize=15)
ax1.set_title('Canal Y - Imagen 1')
ax1.imshow(imagen1yuv[:,:,0], cmap='gray')
ax2.set_title('Canal Y - Imagen 2')
ax2.imshow(imagen2yuv[:,:,0], cmap='gray')
ax3.set_title('Canal Y - Imagen 3')
ax3.imshow(imagen3yuv[:,:,0], cmap='gray')
ax4.set_title('Canal Y - Imagen 4')
ax4.imshow(imagen4yuv[:,:,0], cmap='gray')
ax5.set_title('Canal Y - Imagen 5')
ax5.imshow(imagen5yuv[:,:,0], cmap='gray')

fig, (ax1, ax2, ax3, ax4, ax5) = plt.subplots(1,5, figsize=(15, 6))
fig.suptitle('Canal M - CMY', fontsize=15)
ax1.set_title('Canal M - Imagen 1')
ax1.imshow(255 - imagen1[:,:,1], cmap='gray')
ax2.set_title('Canal M - Imagen 2')
ax2.imshow(255 - imagen2[:,:,1], cmap='gray')
ax3.set_title('Canal M - Imagen 3')
ax3.imshow(255 - imagen3[:,:,1], cmap='gray')
ax4.set_title('Canal M - Imagen 4')
ax4.imshow(255 - imagen4[:,:,1], cmap='gray')
ax5.set_title('Canal M - Imagen 5')
ax5.imshow(255 - imagen5[:,:,1], cmap='gray')

<matplotlib.image.AxesImage at 0x195b3bfdc40>

# Tranformaciones basicas de suma y resta
# img = img_read('images/training/images/34_training.tif')
# img_add = np.zeros(img.shape, np.uint8)

# q = 40 ; w = 40; e = 40;

# img_add[:,:,0] = cv2.add(img[:,:,0], q)
# img_add[:,:,1] = cv2.add(img[:,:,1], w)
# img_add[:,:,2] = cv2.add(img[:,:,2], e)

# fig, arreglo_plots = plt.subplots(2,2, figsize=(15, 15))
# colors = ('r','g','b')

# arreglo_plots[0,0].set_title('Imagen original')
# arreglo_plots[0,0].imshow(img, cmap="gray")
# arreglo_plots[0,1].set_title('Histograma original')
# for i,col in enumerate(colors):
#     img_array_i = img[:,:,i].ravel()
#     arreglo_plots[0,1].hist(img_array_i,histtype='step', bins=255, 
#                             range=(0.0, 255.0),density=True, color=colors[i])
# arreglo_plots[1,0].set_title('Imagen modificada')
# arreglo_plots[1,0].imshow(img_add, cmap="gray")
# arreglo_plots[1,1].set_title('Histograma modificado')
# for i,col in enumerate(colors):
#     img_array_i = img_add[:,:,i].ravel()
#     arreglo_plots[1,1].hist(img_array_i,histtype='step', bins=255, 
#                             range=(0.0, 255.0),density=True, color=colors[i])
    
# #Tranformaciones basicas de multiplicacion y division
# img = img_read('images/training/images/34_training.tif')
# img_mult = np.zeros(img.shape, np.uint8)

# q = 1.8; w = 1.8; e = 1.8;
# img_mult[:,:,0] = cv2.multiply(img[:,:,0], q)
# img_mult[:,:,1] = cv2.multiply(img[:,:,1], w)
# img_mult[:,:,2] = cv2.multiply(img[:,:,2], e)

# fig, arreglo_plots = plt.subplots(2,2, figsize=(15, 15))
# colors = ('r','g','b')

# arreglo_plots[0,0].set_title('Imagen original')
# arreglo_plots[0,0].imshow(img, cmap="gray")
# arreglo_plots[0,1].set_title('Histograma original')
# for i,col in enumerate(colors):
#     img_array_i = img[:,:,i].ravel()
#     arreglo_plots[0,1].hist(img_array_i,histtype='step', bins=255, 
#                             range=(0.0, 255.0),density=True, color=colors[i])

# arreglo_plots[1,0].set_title('Imagen modificada')
# arreglo_plots[1,0].imshow(img_mult, cmap="gray")
# arreglo_plots[1,1].set_title('Histograma modificado')
# for i,col in enumerate(colors):
#     img_array_i = img_mult[:,:,i].ravel()
#     arreglo_plots[1,1].hist(img_array_i,histtype='step', bins=255, 
#                             range=(0.0, 255.0),density=True, color=colors[i])
                            

Filtros:

Se implemento la corrección o transformación Gamma, la cual se usa para manipular el contraste y realzar la imagen. Para este caso con el fin de aumentar el brillo, lo cual nos permitió resaltar la visualización de los vasos.

img_rgb = img_read('images/training/images/35_training.tif')

#Modelo RGB
img_R = img_rgb[:,:,0]
img_G = img_rgb[:,:,1]
img_B = img_rgb[:,:,2]


#Definimos esta función para detectar bordes, la usaremos mas adelante
def detect_edge(image, umbral_min, umbral_max, titulo = "Imagen original",canal = ""): #Angie : añadi un parametro mas que es para poner el nombre del canal
    image_with_edges = cv2.Canny(image , umbral_min, umbral_max)
    
    fig, (ax1, ax2) = plt.subplots(1,2, figsize=(15, 6))
    fig.suptitle(canal, fontsize=15)
    ax1.set_title(titulo)
    ax1.imshow(image, cmap='gray')
    ax2.set_title('Bordes')
    ax2.imshow(image_with_edges, cmap='gray')

#Definir la función de transformación de la imagen (corrección gamma)
def gamma_correction(img, a, gamma):
        
    #Crear copia de la imagen tipo flotante dada la normalización
    img_copy = img.copy().astype(np.float32)/255.0
    #La función corrección gamma es de la forma ax^gamma donde x es la imagen de entrada
    res_gamma = cv2.pow(img_copy, gamma)
    res = cv2.multiply(res_gamma, a)
    
    #Asegurar que la los datos queden entre 0 y 255 y sean uint8
    res[res<0] = 0
    res = res*255.0
    res[res>255] = 255
    
    res = res.astype(np.uint8)
    
    return res

#Leer la imagen de entrada


#Variar los parámetros a y gamma y volver a aplicar la corrección
a = 1.5
gamma = 0.8

res_oscuro = gamma_correction(img_G, a, gamma)

#Usamos nuestra función para observar la diferencia en detección de bordes de la imagen antes y despues de la corrección
detect_edge(img_G, 80, 140)
detect_edge(res_oscuro, 80, 140,"Imagen con corrección gamma")

#se varian los valores de a y gama. 
a= 1.45
gamma = 0.9
#CANAL G - RGB
g_imagen1=gamma_correction(imagen1[:,:,1],a,gamma)
g_imagen2=gamma_correction(imagen2[:,:,1],a,gamma)
g_imagen3=gamma_correction(imagen3[:,:,1],a,gamma)
g_imagen4=gamma_correction(imagen4[:,:,1],a,gamma)
g_imagen5=gamma_correction(imagen5[:,:,1],a,gamma)
#CANAL Y - YUV
ay=1.8 #se varian los valores de a y gama.
gammay=0.9
g_imagen1yuv=gamma_correction(imagen1yuv[:,:,1],ay,gammay)
g_imagen2yuv=gamma_correction(imagen2yuv[:,:,1],ay,gammay)
g_imagen3yuv=gamma_correction(imagen3yuv[:,:,1],ay,gammay)
g_imagen4yuv=gamma_correction(imagen4yuv[:,:,1],ay,gammay)
g_imagen5yuv=gamma_correction(imagen5yuv[:,:,1],ay,gammay)
#CANAL M - CMY
am=1.2 #se varian los valores de a y gama.
gammam=1.2
g_imagen1cmy=gamma_correction(255-imagen1[:,:,1],0.9,gammam)
g_imagen2cmy=gamma_correction(255-imagen2[:,:,1],am,gammam)
g_imagen3cmy=gamma_correction(255-imagen3[:,:,1],am,gammam)
g_imagen4cmy=gamma_correction(255-imagen4[:,:,1],am,gammam)
g_imagen5cmy=gamma_correction(255-imagen5[:,:,1],am,gammam)

#DETECCION DE BORDES

#CANAL G - RGB
detect_edge(imagen1[:,:,1],80,140,"Imagen Original 1","Canal G - RGB")
detect_edge(g_imagen1,80,140,"Imagen con correccion gama")
#Imagen 2
detect_edge(imagen2[:,:,1],60,140,"Imagen Original 2")
detect_edge(g_imagen2,60,140,"Imagen con correccion gama")
#imagen 3
detect_edge(imagen3[:,:,1],60,140,"Imagen Original 3")
detect_edge(g_imagen3,60,140,"Imagen con correccion gama")
#imagen 4
detect_edge(imagen4[:,:,1],60,140,"Imagen Original 4")
detect_edge(g_imagen4,60,140,"Imagen con correccion gama")
#imagen 5
detect_edge(imagen5[:,:,1],60,140,"Imagen Original 5")
detect_edge(g_imagen5,60,140,"Imagen con correccion gama")

# #CANAL Y -YUV
# detect_edge(imagen1yuv[:,:,0],60,140,"Imagen Original 1","Canal Y - YUV")
# detect_edge(g_imagen1yuv,10,70,"Imagen con correccion gama")
# #Imagen 2
# detect_edge(imagen2yuv[:,:,0],60,140,"Imagen Original 2")
# detect_edge(g_imagen2yuv,10,70,"Imagen con correccion gama")
# #imagen 3
# detect_edge(imagen3yuv[:,:,0],60,140,"Imagen Original 3")
# detect_edge(g_imagen3yuv,10,70,"Imagen con correccion gama")
# #imagen 4
# detect_edge(imagen4yuv[:,:,0],60,140,"Imagen Original 4")
# detect_edge(g_imagen4yuv,10,70,"Imagen con correccion gama")
# #imagen 5
# detect_edge(imagen5yuv[:,:,0],60,140,"Imagen Original 5")
# detect_edge(g_imagen5yuv,10,70,"Imagen con correccion gama")

# #CANAL M - CMY
# detect_edge(255-imagen1[:,:,1],60,140,"Imagen Original 1","Canal M - CMY")
# detect_edge(g_imagen1cmy,60,140,"Imagen con correccion gama")
# #imagen 2
# detect_edge(255-imagen2[:,:,1],60,140,"Imagen Original 2")
# detect_edge(g_imagen2cmy,60,140,"Imagen con correccion gama")
# #imagen 3
# detect_edge(255-imagen3[:,:,1],60,140,"Imagen Original 3")
# detect_edge(g_imagen3cmy,60,140,"Imagen con correccion gama")
# #imagen 4
# detect_edge(255-imagen4[:,:,1],60,140,"Imagen Original 4")
# detect_edge(g_imagen4cmy,60,140,"Imagen con correccion gama")
# #imagen 5
# detect_edge(255-imagen5[:,:,1],60,140,"Imagen Original 5")
# detect_edge(g_imagen5cmy,60,140,"Imagen con correccion gama")

#Definir la función ecualización del histograma cuyo parámetro es una imagen
img_rgb1 = img_read('images/training/images/29_training.tif')
#Modelo RGB
img_G2 = img_rgb1[:,:,1]

def histogram_equalization(img):
         
    #Crear matriz de ceros del tamaño de la imagen y tipo de dato flotante
    res = np.zeros(img.shape, np.float32)
    #Crear un vector 1-D de la matriz de la imagen es decir \aplanarla\
    img_raveled = img.ravel()
    #Generar el histograma normalizado de la imagen 
    hist_norm = plt.hist(img_raveled, bins=255, range=(0.0, 255.0), density=True)
    #Limpiar la figura actual
    plt.clf()
    #hist_norm[0] es un vector de probabilidades. Añadir al vector el valor [1 - sumatoria de sus datos]
    pdf = hist_norm[0]
    np.append(pdf, 1.0 - np.sum(pdf))
    #Dado que se añade un dato se realiza la sumatoria de valores sobre todo el vector
    cdf = [np.sum(pdf[0:x]) for x in range(0,256)]
    #Hallar el valor mínimo y máximo de la imagen
    gmin = np.min(img)
    gmax = np.max(img)
    
    #Generar F(g) - Función de ecualización
    for g in range(0,256):
        res[img == g] = (gmax - gmin)*cdf[g] + gmin
    #Asegurar que los datos sean uint8 y esten en el rango correspondiente
    res[res<0] = 0
    res[res>255] = 255
    res = res.astype(np.uint8)
    return res

#Leer la imagen y aplicar la transformación ecualización del histograma sobre ésta

res_ecua= histogram_equalization(img_G2)

#Generar subplot 2x3 para mostrar imagen histograma y función de densidad acumulada
fig, arreglo_plots = plt.subplots(2,2 ,figsize=(10 ,10))
colors = ('r','g','b')

arreglo_plots[0,0].set_title('Imagen original')
arreglo_plots[0,0].imshow(img_G2, cmap='gray')
arreglo_plots[0,1].set_title('Histograma original')
img_array_i = img_G.ravel()
_=arreglo_plots[0,1].hist(img_array_i,histtype='step', bins=255 ,
                            range=(0.0, 255.0),density=True ,color=colors[1])

arreglo_plots[1,0].set_title('Imagen modificada')
arreglo_plots[1,0].imshow(res_ecua, cmap="gray")
arreglo_plots[1,1].set_title('Histograma modificado')
img_array_i = res_ecua.ravel()
_=arreglo_plots[1,1].hist(img_array_i,histtype='step', bins=255,
                          range=(0.0, 255.0),density=True, color=colors[1])

<Figure size 432x288 with 0 Axes>

#funcion para mostrar la ecualizacion de las imagenes
def mostrar_eh(img1,img2,imagen="",canal=""):
    fig, arreglo_plots = plt.subplots(1,4 ,figsize=(20 ,3))
    fig.suptitle(canal,fontsize=16)
    colors = ('r','g','b')

    arreglo_plots[0].set_title(imagen)
    arreglo_plots[0].imshow(img1, cmap='gray')
    arreglo_plots[1].set_title('Histograma original')
    img_array_i = img1.ravel()
    _=arreglo_plots[1].hist(img_array_i,histtype='step', bins=255 ,
                                range=(0.0, 255.0),density=True ,color=colors[1])
    arreglo_plots[2].set_title("Imagen Modificada")
    arreglo_plots[2].imshow(img2, cmap="gray")
    arreglo_plots[3].set_title('Histograma modificado')
    img_array_i = img2.ravel()
    _=arreglo_plots[3].hist(img_array_i,histtype='step', bins=255,
                              range=(0.0, 255.0),density=True, color=colors[1])

#aplicacion de ecualizacion
#CANAL G - RGB
e_imagen1=histogram_equalization(imagen1[:,:,1])
e_imagen2=histogram_equalization(imagen2[:,:,1])
e_imagen3=histogram_equalization(imagen3[:,:,1])
e_imagen4=histogram_equalization(imagen4[:,:,1])
e_imagen5=histogram_equalization(imagen5[:,:,1])

#CANAL Y -YUV
e_imagen1yuv=histogram_equalization(imagen1yuv[:,:,1])
e_imagen2yuv=histogram_equalization(imagen2yuv[:,:,1])
e_imagen3yuv=histogram_equalization(imagen3yuv[:,:,1])
e_imagen4yuv=histogram_equalization(imagen4yuv[:,:,1])
e_imagen5yuv=histogram_equalization(imagen5yuv[:,:,1])

#CANAL M - CMY
e_imagen1cmy=histogram_equalization(255-imagen1[:,:,1])
e_imagen2cmy=histogram_equalization(255-imagen2[:,:,1])
e_imagen3cmy=histogram_equalization(255-imagen3[:,:,1])
e_imagen4cmy=histogram_equalization(255-imagen4[:,:,1])
e_imagen5cmy=histogram_equalization(255-imagen5[:,:,1])

mostrar_eh(imagen1[:,:,1],e_imagen1,"Imagen original 1","Canal G - RGB"+"\n")
mostrar_eh(imagen2[:,:,1],e_imagen2,"Imagen original 2")
mostrar_eh(imagen3[:,:,1],e_imagen3,"Imagen original 3")
mostrar_eh(imagen4[:,:,1],e_imagen4,"Imagen original 4")
mostrar_eh(imagen5[:,:,1],e_imagen5,"Imagen original 5")

# mostrar_eh(imagen1yuv[:,:,0],e_imagen1yuv,"Imagen original 1","Canal Y - YUV")
# mostrar_eh(imagen2yuv[:,:,0],e_imagen2yuv,"Imagen original 2")
# mostrar_eh(imagen3yuv[:,:,0],e_imagen3yuv,"Imagen original 3")
# mostrar_eh(imagen4yuv[:,:,0],e_imagen4yuv,"Imagen original 4")
# mostrar_eh(imagen5yuv[:,:,0],e_imagen5yuv,"Imagen original 5")

# mostrar_eh(255-imagen1[:,:,1],e_imagen1cmy,"Imagen original 1","Canal M - CMY")
# mostrar_eh(255-imagen2[:,:,1],e_imagen2cmy,"Imagen original 2")
# mostrar_eh(255-imagen3[:,:,1],e_imagen3cmy,"Imagen original 3")
# mostrar_eh(255-imagen4[:,:,1],e_imagen4cmy,"Imagen original 4")
# mostrar_eh(255-imagen5[:,:,1],e_imagen5cmy,"Imagen original 5")

<Figure size 432x288 with 0 Axes>

res_gauss= cv2.GaussianBlur(res_ecua,(5, 5),2)
detect_edge(res_gauss, 60, 140, "Filtro gaussiano")

res_gauss2=cv2.GaussianBlur(e_imagen5,(5,5),2)
detect_edge(res_gauss2, 60, 140, "Filtro gaussiano")

#definicion de funcion para la aplicacion del filtro de media.
def filtro_mediab(imag,k_size):
    #Aplica suavizado mediante la funcion blur
    res1 = cv2.blur(imag,(k_size,k_size),borderType=cv2.BORDER_REPLICATE )
    
    return res1

def filtro_media2d(imag,k_size):
    #Aplica suavizado mediante filter2D
    kernel = np.ones((k_size,k_size),np.float64)/(k_size**2)
    res2 = cv2.filter2D(imag, ddepth=-1, kernel= kernel, borderType=cv2.BORDER_REPLICATE)
    
    return res2

k_size=6 #valor tamaño del kernel
#CANAL G - RGB
fmb_imagen1,fmd_imagen1 = filtro_mediab(e_imagen1,k_size),filtro_media2d(e_imagen1,k_size) 
fmb_imagen2,fmd_imagen2 = filtro_mediab(e_imagen2,k_size),filtro_media2d(e_imagen2,k_size) 
fmb_imagen3,fmd_imagen3 = filtro_mediab(e_imagen3,k_size),filtro_media2d(e_imagen3,k_size) 
fmb_imagen4,fmd_imagen4 = filtro_mediab(e_imagen4,k_size),filtro_media2d(e_imagen4,k_size) 
#solo se mostro el filtro en la imagen 5
fmb_imagen5,fmd_imagen5 = filtro_mediab(e_imagen5,k_size),filtro_media2d(e_imagen5,k_size) 
detect_edge(e_imagen5, 50, 120, "Imagen Ecualizada", "Imagen 5, Canal G - RGB")
detect_edge(fmb_imagen5, 50, 120, "Funcion Blur")
detect_edge(fmd_imagen5, 50, 120, "Funcion Filter2D")

# #IMAGEN 5 CANAL Y -YUV
# fmb_imagen1y,fmd_imagen1y = filtro_mediab(e_imagen1yuv,k_size),filtro_media2d(e_imagen1yuv,k_size) 
# fmb_imagen2y,fmd_imagen2y = filtro_mediab(e_imagen2yuv,k_size),filtro_media2d(e_imagen2yuv,k_size) 
# fmb_imagen3y,fmd_imagen3y = filtro_mediab(e_imagen3yuv,k_size),filtro_media2d(e_imagen3yuv,k_size) 
# fmb_imagen4y,fmd_imagen4y = filtro_mediab(e_imagen4yuv,k_size),filtro_media2d(e_imagen4yuv,k_size)
# #solo se mostro el filtro en la imagen 5
# fmb_imagen5y,fmd_imagen5y = filtro_mediab(e_imagen5yuv,k_size),filtro_media2d(e_imagen5yuv,k_size) 
# detect_edge(e_imagen5yuv, 20, 50, "Imagen Ecualizada", "Imagen 5, Canal Y - YUV")
# detect_edge(fmb_imagen5y, 20, 50, "Funcion Blur")
# detect_edge(fmd_imagen5y, 20, 50, "Funcion Filter2D")

# #IMAGEN 5 CANAL M - CMY
# fmb_imagen1m,fmd_imagen1m = filtro_mediab(e_imagen1cmy,k_size),filtro_media2d(e_imagen1cmy,k_size) 
# fmb_imagen2m,fmd_imagen2m = filtro_mediab(e_imagen2cmy,k_size),filtro_media2d(e_imagen2cmy,k_size) 
# fmb_imagen3m,fmd_imagen3m = filtro_mediab(e_imagen3cmy,k_size),filtro_media2d(e_imagen3cmy,k_size) 
# fmb_imagen4m,fmd_imagen4m = filtro_mediab(e_imagen4cmy,k_size),filtro_media2d(e_imagen4cmy,k_size) 
# fmb_imagen5m,fmd_imagen5m = filtro_mediab(e_imagen5cmy,k_size),filtro_media2d(e_imagen5cmy,k_size)
# #solo se mostro el filtro en la imagen 5
# detect_edge(e_imagen5cmy, 30, 120, "Imagen Ecualizada", "Imagen 5, Canal M - CMY")
# detect_edge(fmb_imagen5m, 30, 120, "Funcion Blur")
# detect_edge(fmd_imagen5m, 30, 120, "Funcion Filter2D")

#Definir tamaño del kernel
k_size = 9
#Aplicar filtro de mediana a la imagen de entrada
res1_g= cv2.medianBlur(e_imagen1, k_size)
res2_g= cv2.medianBlur(e_imagen2, k_size)
res3_g= cv2.medianBlur(e_imagen3, k_size)
res4_g= cv2.medianBlur(e_imagen4, k_size)
res5_g= cv2.medianBlur(e_imagen5, k_size)

res1_y= cv2.medianBlur(e_imagen1yuv, k_size)
res2_y= cv2.medianBlur(e_imagen2yuv, k_size)
res3_y= cv2.medianBlur(e_imagen3yuv, k_size)
res4_y= cv2.medianBlur(e_imagen4yuv, k_size)
res5_y= cv2.medianBlur(e_imagen5yuv, k_size)

res1_m= cv2.medianBlur(e_imagen1cmy, k_size)
res2_m= cv2.medianBlur(e_imagen2cmy, k_size)
res3_m= cv2.medianBlur(e_imagen3cmy, k_size)
res4_m= cv2.medianBlur(e_imagen4cmy, k_size)
res5_m= cv2.medianBlur(e_imagen5cmy, k_size)

#Solo se mostro la imagen 5 de cada canal escogido.
detect_edge(e_imagen5,50,130,"Imagen Original 5 Ecualizada","Canal G-RGB")
detect_edge(res5_g,50,130,"Imagen con filtro")

# detect_edge(e_imagen5yuv,10,55,"Imagen Original 5 Ecualizada","Canal Y - YUV")
# detect_edge(res5_y,10,55,"Imagen con filtro")

# detect_edge(e_imagen5cmy,30,140,"Imagen Original 5 Ecualizada","Canal M - CMY")
# detect_edge(res5_m,30,140,"Imagen con filtro")

#Definir función filtro del mínimo
def minimum_filter(img,k_size):
    #Crear matriz de ceros del tamaño de imagen de entrada
    res = np.zeros(img.shape, np.uint8)
    #Definir el radio del kernel
    r = math.floor(k_size/2)
    #Recorrer cada posición i,j de la imagen con el kernel
    for i in range(r, img.shape[0]-r):
        for j in range(r, img.shape[1]-r):
            #Tamaño de la ventana 
            window = img[i-r:i+r+1,j-r:j+r+1]
            #Cambiar el valor de la posición i,j de la imagen por el de la ventana
            min_val = np.min(window)
            res[i,j] = min_val
    return res
fig, (ax1) = plt.subplots(1, figsize=(15, 6))

ax1.imshow(minimum_filter(e_imagen5, 6), cmap ='gray')
detect_edge(minimum_filter(e_imagen5, k_size), 10, 120, "Filtro minimo")

#Definir función de Filtro del Máximo
def maximum_filter(img,k_size):
    #Crear una matriz de ceros del tamaño de la imagen de entrada
    res = np.zeros(img.shape, np.uint8)
    #Radio del kernel
    r = math.floor(k_size/2)
    #Recorrer cada posición i,j de la imagen con el kernel
    for i in range(r, img.shape[0]-r):
        for j in range(r, img.shape[1]-r):
            #Tamaño de la ventana 
            window = img[i-r:i+r+1,j-r:j+r+1]
            #Cambiar el valor de la posición i,j de la imagen por el de la ventana
            max_val = np.max(window)
            res[i,j] = max_val
    return res

fig, (ax1) = plt.subplots(1, figsize=(15, 6))

ax1.imshow(maximum_filter(e_imagen5, k_size), cmap ='gray')
detect_edge(maximum_filter(e_imagen5, k_size), 10, 120, "Filtro maximo")